from django.contrib.auth.mixins import LoginRequiredMixin
from django.shortcuts import render
from django.views import View
from users.models import Address
from django_redis import get_redis_connection
from decimal import Decimal
from goods.models import SKU
import json
from django import http
from orders.models import OrderGoods, OrderInfo
from django.utils import timezone
from meiduo_mall.utils.response_code import RETCODE
from django.db import transaction
# from meiduo_mall.utils.views import LoginRequiredMixin
# Create your views here.
class OrderSuccessView(LoginRequiredMixin, View):
    """提交订单成功"""
    def get(self, request):
        order_id = request.GET.get('order_id')
        payment_amount = request.GET.get('payment_amount')
        pay_method = request.GET.get('pay_method')

        context = {
            'order_id': order_id,
            'payment_amount': payment_amount,
            'pay_method': pay_method
        }
        return render(request, 'order_success.html', context)


class OrderCommitView(View):
    """订单提交"""
    def post(self, request):
        """保存订单信息和订单商品信息"""
        #  获取当前要保存的订单信息
        json_dict = json.loads(request.body.decode())
        address_id = json_dict.get('address_id')
        pay_method = json_dict.get('pay_method')

        #  校验参数
        if not all([address_id, pay_method]):
            return http.HttpResponseForbidden('缺少必传参数')
        #  判断address_id是否合法
        try:
            address = Address.objects.get(id=address_id)
        except Exception:
            return http.HttpResponseForbidden('参数address_id缺少')

        #  判断pay_method是否合法
        if pay_method not in [OrderInfo.PAY_METHODS_ENUM['CASH'], OrderInfo.PAY_METHODS_ENUM['ALIPAY']]:
            return http.HttpResponseForbidden('参数pay_method错误')

        #  显式的开启事物
        with transaction.atomic():
            #  创建事物保存点
            save_id = transaction.savepoint()

            #  暴力回滚
            try:
                #  获取登录用户
                user = request.user
                #  生成订单编号
                order_id = timezone.localtime().strftime('%Y%m%d%H%M%S') + ('%09d' % user.id)
                #  保存订单基本信息 OrderInfo
                order = OrderInfo.objects.create(
                    order_id = order_id,
                    user = user,
                    address = address,
                    total_count = 0,
                    total_amount = Decimal(0),
                    freight = Decimal('10.00'),
                    pay_method = pay_method,
                    status = OrderInfo.ORDER_STATUS_ENUM['UNPAID'] if pay_method == OrderInfo.PAY_METHODS_ENUM['ALIPAY'] else OrderInfo.ORDER_STATUS_CHOICES['UNSEND']
                )
                #  从redis读取购物车中被勾选的商品信息
                redis_conn = get_redis_connection('carts')
                redis_cart = redis_conn.hgetall('carts_%s' % user.id)
                selected = redis_conn.smembers('selected_%s' % user.id)
                carts = {}
                for sku_id in selected:
                    carts[int(sku_id)] = int(redis_cart[sku_id])
                sku_ids = carts.keys()
                #  遍历购物车中被勾选的商品信息
                for sku_id in sku_ids:
                    #  每个商品都有下单的机会，直到库存不足
                    while True:
                        #  查询sku信息
                        sku = SKU.objects.get(id=sku_id)

                        #读取原始数据
                        origin_stock = sku.stock
                        origin_sales = sku.sales

                        #  判断库存
                        sku_count = carts[sku.id]
                        if sku_count > origin_stock:
                            #  出错就回滚
                            transaction.savepoint_rollback(save_id)
                            return http.JsonResponse({'code': RETCODE.STOCKERR, 'errmsg': '库存不足'})

                        # #  SKU减少库存，增加销量
                        # sku.stock -= sku_count
                        # sku.sales += sku_count
                        # sku.save()


                        #  乐观锁更新库存和销量
                        new_stock = origin_stock - sku_count
                        new_sales = origin_sales + sku_count
                        result = SKU.objects.filter(id=sku_id, stock=origin_stock).update(stock=new_stock, sales=new_sales)

                        #  如果下单失败，但是库存仍然足够时，继续下单
                        if result == 0:
                            continue

                        #  修改spu销量
                        sku.spu.sales += sku_count
                        sku.spu.save()

                        #  保存订单商品信息OrderGoods
                        OrderGoods.objects.create(
                            order=order,
                            sku=sku,
                            count=sku_count,
                            price=sku.price,

                        )

                        #  保存商品订单中总价和总数量
                        order.total_count += sku_count
                        order.total_amount += (sku_count * sku.price)

                        #  下单成功或者失败就跳出循环
                        break

                #  添加邮费和保存订单消息
                order.total_amount += order.freight
                order.save()
            except Exception as e:
                transaction.savepoint_rollback(save_id)
                return http.JsonResponse({'code': RETCODE.DBERR, 'errmsg': '下单失败'})

            #  提交事物
            transaction.savepoint_commit(save_id)

        #  清除购物车中已结算的商品
        pl = redis_conn.pipeline()
        pl.hdel('carts_%s' % user.id, *selected)
        pl.srem('selected_%s' % user.id, *selected)
        pl.execute()

        #  响应提交订单结果
        return http.JsonResponse({'code': RETCODE.OK, 'errmsg': '下单成功', 'order_id': order.order_id})


class OrderSettlementView(LoginRequiredMixin, View):
    """结算账单"""
    def get(self, request):
        """提供订单结算页面"""
        #  获取用户登录
        user = request.user
        #  查询地址信息
        try:
            addresses = Address.objects.filter(user=user, is_deleted=False)
        except Address.DoesNotExist:
            addresses = None

        #  从redis购物车中查询出被勾选的商品信息
        redis_conn = get_redis_connection('carts')
        redis_cart = redis_conn.hgetall('carts_%s' % user.id)
        cart_selected = redis_conn.smembers('selected_%s' % user.id)
        cart = {}
        for sku_id in cart_selected:
            cart[int(sku_id)] = int(redis_cart[sku_id])

        #  准备初始值
        total_count = 0
        total_amount = Decimal(0.00)
        #  查询商品信息
        skus = SKU.objects.filter(id__in=cart.keys())
        for sku in skus:
            sku.count = cart[sku.id]
            sku.amount = sku.count * sku.price
            #  计算总数量和总数额
            total_count += sku.count
            total_amount += sku.count * sku.price

        #  补充运费
        freight = Decimal('10.00')

        #  渲染页面
        context = {
            'addresses': addresses,
            'skus': skus,
            'total_count': total_count,
            'total_amount': total_amount,
            'freight': freight,
            'payment_amount': total_amount + freight
        }

        return render(request, 'place_order.html', context)